// Java
package com.cl.service.impl;

import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.cl.utils.PageUtils;
import com.cl.utils.Query;

import com.cl.dao.KechengqiandaoDao;
import com.cl.entity.KechengqiandaoEntity;
import com.cl.service.KechengqiandaoService;
import com.cl.entity.view.KechengqiandaoView;

/**
 * 课程签到服务实现类
 * 提供课程签到相关的业务逻辑实现
 */
@Service("kechengqiandaoService")
public class KechengqiandaoServiceImpl extends ServiceImpl<KechengqiandaoDao, KechengqiandaoEntity> implements KechengqiandaoService {
    
    private static final Logger logger = LoggerFactory.getLogger(KechengqiandaoServiceImpl.class);
    
    /**
     * 分页查询课程签到数据
     * @param params 查询参数
     * @return 分页结果
     * @throws IllegalArgumentException 如果参数无效
     */
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        validateParams(params);
        logger.debug("执行基本分页查询, 参数: {}", params);
        
        try {
            Page<KechengqiandaoEntity> page = this.selectPage(
                    new Query<KechengqiandaoEntity>(params).getPage(),
                    new EntityWrapper<KechengqiandaoEntity>()
            );
            return new PageUtils(page);
        } catch (Exception e) {
            logger.error("分页查询失败", e);
            throw new RuntimeException("查询数据失败", e);
        }
    }

    /**
     * 分页查询课程签到数据（带条件）
     * @param params 查询参数
     * @param wrapper 查询条件包装器
     * @return 分页结果
     * @throws IllegalArgumentException 如果参数无效
     */
    @Override
    public PageUtils queryPage(Map<String, Object> params, Wrapper<KechengqiandaoEntity> wrapper) {
        validateParams(params);
        validateWrapper(wrapper);
        logger.debug("执行条件分页查询, 参数: {}", params);
        
        try {
            Page<KechengqiandaoView> page = new Query<KechengqiandaoView>(params).getPage();
            page.setRecords(baseMapper.selectListView(page, wrapper));
            return new PageUtils(page);
        } catch (Exception e) {
            logger.error("条件分页查询失败", e);
            throw new RuntimeException("条件查询数据失败", e);
        }
    }

    /**
     * 查询课程签到视图列表
     * @param wrapper 查询条件包装器
     * @return 视图列表
     * @throws IllegalArgumentException 如果参数无效
     */
    @Override
    public List<KechengqiandaoView> selectListView(Wrapper<KechengqiandaoEntity> wrapper) {
        validateWrapper(wrapper);
        logger.debug("查询视图列表");
        
        try {
            return baseMapper.selectListView(wrapper);
        } catch (Exception e) {
            logger.error("查询视图列表失败", e);
            throw new RuntimeException("查询视图列表失败", e);
        }
    }

    /**
     * 查询单个课程签到视图
     * @param wrapper 查询条件包装器
     * @return 单个视图对象，如果未找到则返回null
     * @throws IllegalArgumentException 如果参数无效
     */
    @Override
    public KechengqiandaoView selectView(Wrapper<KechengqiandaoEntity> wrapper) {
        validateWrapper(wrapper);
        logger.debug("查询单个视图");
        
        try {
            return baseMapper.selectView(wrapper);
        } catch (Exception e) {
            logger.error("查询单个视图失败", e);
            throw new RuntimeException("查询单个视图失败", e);
        }
    }

    /**
     * 查询统计值
     * @param params 查询参数
     * @param wrapper 查询条件包装器
     * @return 统计值列表
     * @throws IllegalArgumentException 如果参数无效
     */
    @Override
    public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<KechengqiandaoEntity> wrapper) {
        validateParams(params);
        validateWrapper(wrapper);
        logger.debug("查询统计值, 参数: {}", params);
        
        try {
            return baseMapper.selectValue(params, wrapper);
        } catch (Exception e) {
            logger.error("查询统计值失败", e);
            throw new RuntimeException("查询统计值失败", e);
        }
    }

    /**
     * 查询时间统计值
     * @param params 查询参数
     * @param wrapper 查询条件包装器
     * @return 时间统计值列表
     * @throws IllegalArgumentException 如果参数无效
     */
    @Override
    public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<KechengqiandaoEntity> wrapper) {
        validateParams(params);
        validateWrapper(wrapper);
        logger.debug("查询时间统计值, 参数: {}", params);
        
        try {
            return baseMapper.selectTimeStatValue(params, wrapper);
        } catch (Exception e) {
            logger.error("查询时间统计值失败", e);
            throw new RuntimeException("查询时间统计值失败", e);
        }
    }

    /**
     * 查询分组统计值
     * @param params 查询参数
     * @param wrapper 查询条件包装器
     * @return 分组统计值列表
     * @throws IllegalArgumentException 如果参数无效
     */
    @Override
    public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<KechengqiandaoEntity> wrapper) {
        validateParams(params);
        validateWrapper(wrapper);
        logger.debug("查询分组统计值, 参数: {}", params);
        
        try {
            return baseMapper.selectGroup(params, wrapper);
        } catch (Exception e) {
            logger.error("查询分组统计值失败", e);
            throw new RuntimeException("查询分组统计值失败", e);
        }
    }

    /**
     * 校验查询参数
     * @param params 查询参数
     * @throws IllegalArgumentException 如果参数为空或无效
     */
    private void validateParams(Map<String, Object> params) {
        if (params == null || params.isEmpty()) {
            logger.warn("查询参数为空");
            throw new IllegalArgumentException("参数不能为空");
        }
    }
    
    /**
     * 校验查询条件包装器
     * @param wrapper 查询条件包装器
     * @throws IllegalArgumentException 如果包装器为null
     */
    private void validateWrapper(Wrapper<KechengqiandaoEntity> wrapper) {
        Objects.requireNonNull(wrapper, "查询条件不能为空");
    }
}